package org.example.until;

import org.example.entity.ACar;
import org.example.entity.BCar;
import org.example.listener.ACarListener;
import org.example.listener.BCarListener;

import java.util.*;

public class StringSimilarity {
    public static Map<String, List<String[]>> map = new HashMap<>();//一个sheet只能用一个hash只需要创建一次

    //将list中的每一个前三个字符作为key
    //key为前三个字符串，value为后面的字符串集，
    //但是由于前三个字符串后很多相同的因此必须用List来装
    public static void buildMap(List<ACar> list) {//构建a表的哈希表
        List<String[]> arrayList = new ArrayList<>();//每执行一次查询都需要创建一个新的list也就是一个新的value
        for (ACar aCar : list) {
            String[] strings = aCar.getAName().split(" ");//将每个aCar信息拆分成一个字符串
            String frontTree = strings[0] + strings[1] + strings[2];
            String[] backString = new String[strings.length - 3];//后面的字符作为关键字用于被搜索
            for (int i = 3; i < strings.length; i++) {
                backString[i - 3] = strings[i];
            }
            //此时string[]已经准备好但是由于有很多个string[]因此我们需要用一个List<String[]>结构用于value
            arrayList.add(backString);//现在value准备完毕
            map.put(frontTree, arrayList);//键值对构成
        }
    }

    //如果是通过b找a，b的关键字有可能少于a因此导致查询次数不够因此需要再次处理

    public static String findLastName(String key, String bLastName,String s) {//bLastName例如 四驱旗舰版
        String mostSimilarity = s;
        for (String[] alist : map.get(key)) {//遍历hash的key
            for (String a : alist) {//遍历string[]
                if (bLastName.equals(a)) {//如果相同则直接返回,第一种情况都到达末尾才会相同
                    return a+" ";
                } else if (bLastName.contains(a)) {//第二种情况b到达末尾而a没有到达末尾
                    if (bLastName.split(a).length == 1 && bLastName.equals(bLastName.split(a))) {//就根据s进行分割如果分割后字符组长度==1并且里面的内容完全与分割前一样
                        //说明分割失败s的内容不是连续在blastname里面存在的这种情况无需处理需要继续遍历
                        continue;
                    } else if (bLastName.split(a).length == 1 && !bLastName.equals(bLastName.split(a))) {//如果说分割过后length!=1但内容不相同说明分割成功
                        if (bLastName.split(a)[0].length() > 1) {
                            mostSimilarity += a+" ";//我们就将这部分a与b共有的加入进去
                            //并且再次调用这个函数
                            findLastName(key, bLastName.split(a)[0],mostSimilarity);//因为只剩下一个[0]所以直接进行
                        } else {//如果说切割到最后没有东西了说明递归完毕直接退出，但有种情况比如说剩一个版和型对不上那么就需要直接把这一段完整插入进去
                            return mostSimilarity += a+" ";
                        }
                    }else if(bLastName.split(a).length>1){
                        for (String s1 : bLastName.split(a)) {
                            return findLastName(key,s1,mostSimilarity)+" ";//分别进行切割添加
                        }
                    }

                }
            }
        }
        return mostSimilarity;
    }
    public static String mapNotFount(String bName){
        //如果没有找到有两种情况一种是真没有一种则是Map的Key没有搜寻到，
        //那么我将单独对这部分进行处理
        //直接暴力搜寻从第一个字符串开始搜寻
        //strings[]存储的是当前读取a表中的字符串集合
        //bCars是b读取过后所有的集合
        String mostSimilar = "";//用于返回找到的a的名字
        String[] strings = bName.split(" ");//先将bName分成key，value

        List<String[]> aList=new ArrayList<>();
        //准备数据
        for (int i = 0; i < ACarListener.aCars.size(); i++) {//将A的数据准备好
            aList.add(ACarListener.aCars.get(i).getAName().split(" "));
        }
        for (String b : strings) {//b的关键字
            boolean isFind=false;//同样也是判断是否成功
            for (String[] bs : aList) {//b的字符串集合
                for (String a : bs) {//a关键字
                    if(b.equals(a)||a.contains(b)){
                        mostSimilar+=a+" ";
                        isFind=true;
                        break;//找到b在a中对应的了直接break去找下一个a
                    }

                }
                if (isFind){//如果找到了就退出这层循环去找下一个b的关键字
                    break;
                }
            }

        }
        //for循环执行完毕之后应该找到所有的了直接返回现在的mostSimilar
        System.out.println("暴力找到的" + mostSimilar);
        return mostSimilar;
    }
    public static String find(String bName) {//传过来b的名字用于找到a的名字
        String[] strings = bName.split(" ");//先将bName分成key，value
        String mostSimilar =strings[0] + strings[1] + strings[2] ;//用于返回找到的a的名字
        if (map.get(strings[0] + strings[1] + strings[2]) == null) {//map找不到
            String b=mapNotFount(bName);
            System.out.println("mapNotFount找到===="+b);
            return b;
        }
        for (int i = 4; i < strings.length; i++) {  //i=0,1,2都是key，而3 a中不需要因此从4开始
            boolean isFind = false;//用来判断是否找到
            if (i == strings.length - 1) {//如果到达了b的最后一个关键字则单独进行处理
                return mostSimilar += findLastName(strings[0] + strings[1] + strings[2], strings[i],strings[0] +" "+ strings[1]+" " + strings[2]+" ");
            } else {

                for (String[] as : map.get(strings[0] + strings[1] + strings[2])) {//获取到a的后面字符组
                    for (String a : as) {
                        if (a != null && strings[i] != null && (a.equals(strings[i]) || strings[i].contains(a))) {//如果a等于b的后几个字符串中的一个
                            isFind = true;//找到了
                            mostSimilar += a + " ";//将其拼接上
                            break;//找到后直接退出当前循环去寻找下一个关于b的关键字对应的a关键字
                        }
                    }
                    if (isFind) {
                        //如果找到了就不必在as集合中去寻找了直接去寻找下一个关于b的关键字对应的a
                        break;
                    }
                }
            }
        }
        System.out.println("hash找到===" + mostSimilar);
        return mostSimilar;
    }
}



